from autoservis.servis.models import *
from django.shortcuts import render_to_response, get_object_or_404
from autoservis.servis import settings
import math
from django.http import HttpResponse
import datetime
from django.db import transaction
import os

def index(request):
	cin, cout = os.popen2('/usr/games/fortune')
	lines = cout.read()
	cin.close()
	cout.close()
	return render_to_response('servis/index.html', {'tip':lines})

def detailZakaznika(request, zakaznik_id):
	 cust = get_object_or_404(Zakaznik, id = zakaznik_id)
	 zakazka_list = Zakazka.objects.filter(zakaznik=cust)
	 return	render_to_response('servis/Zakaznik_detail.html',{'cust':cust, 'zakazky':zakazka_list})

def zakaznici(request):
	return zakazniciPage(request,0)
	
def zakazniciPage(request, zakaznici_page):
	zakaznici_page = int(zakaznici_page)
	zakaznici = Zakaznik.objects.all()
	zakaznici_list = zakaznici.order_by('-id')[settings.PAGEITEMS*zakaznici_page :  settings.PAGEITEMS*(zakaznici_page+1)]
	
	pocet_stran = math.ceil(len(zakaznici)/settings.PAGEITEMS)

	zakaznici_list_modified = []
	
	for s in zakaznici_list:
		sm = {'id': s.id, 'prijmeni': s.prijmeni, 'jmeno':s.jmeno,
		       		'mesto': s.mesto, 'ulice':s.ulice,
			       	'psc':s.psc, 'telefon':s.telefon,
			       	'zisk':	zakaznikZisk(s.id)}
		zakaznici_list_modified.append(sm)

	predchozi = (zakaznici_page != 0) and (zakaznici_page - 1)
	nasledujici = (zakaznici_page < pocet_stran) and (zakaznici_page
			+ 1)
		
	return	render_to_response('servis/viewCustomers.html',{'cust_list':zakaznici_list_modified,'zakaznici_page':
			zakaznici_page,
			'predchozi':predchozi, 'nasledujici':nasledujici})
def novyZakaznik(request):
	return render_to_response('servis/novyZakaznik.html')
@transaction.commit_on_success
def vytvoreniZakaznika(request):
	jmeno = request.POST['jmeno']
	prijmeni = request.POST['prijmeni']
	mesto = request.POST['mesto']
	psc = request.POST['psc']
	ulice = request.POST['ulice']
	telefon = request.POST['telefon']
	if jmeno and prijmeni and mesto and psc and ulice  and telefon:
		maxId = len(Zakaznik.objects.all())+1
		z = Zakaznik(id=maxId, jmeno=jmeno, prijmeni=prijmeni,
				mesto=mesto, psc=psc,
				ulice=ulice,telefon=telefon)	
		try:
			z.save()
			return uspech(request, 'Uspesne pridani zakaznika')
		except:
			return chyba(request, 'Chyba pri zapisovani zakaznika')
	else:
		return novyZakaznikZnovu(request,jmeno, prijmeni, mesto, psc,
				ulice, telefon)

def chyba(request, popis):
	return render_to_response('servis/chyba.html',{'popis':popis})
def novyZakaznikZnovu(request, jmeno, prijmeni, mesto, psc,
		ulice,telefon):
	return 	render_to_response('servis/novyZakaznik.html',{'jmeno':jmeno,
			'prijmeni':prijmeni, 'mesto':mesto, 'psc':psc,
			'ulice':ulice, 'telefon':telefon, 'popis':'Je nutne vyplnit vsechna potrebna pole'})
def uspech(request, popis):
	return render_to_response('servis/uspech.html',{'popis':popis})
def upravitZakaznika(request, zakaznik_id):
	 cust = get_object_or_404(Zakaznik, id = zakaznik_id)
	 return render_to_response('servis/Zakaznik_detail.html',{'cust':cust, 'upravit':1})
@transaction.autocommit
def upravovaniZakaznika(request, zakaznik_id):
	try:
        	z = Zakaznik.objects.get(id=zakaznik_id)
	except ObjectDoesNotExist:
        	return http.HttpResponseNotFound()

	jmeno = request.POST['jmeno']
	prijmeni = request.POST['prijmeni']
	mesto = request.POST['mesto']
	psc = request.POST['psc']
	ulice = request.POST['ulice']
	telefon = request.POST['telefon']

	if jmeno and prijmeni and mesto and psc and ulice  and telefon:
		z.jmeno =  jmeno
		z.prijmeni = prijmeni
		z.mesto = mesto
		z.psc = psc
		z.ulice = ulice
		z.telefon = telefon
		z.save()
		return uspech(request,'Data uspesne aktualizovana')
	else:
	 	cust = get_object_or_404(Zakaznik, id = zakaznik_id)
		return 	render_to_response('servis/Zakaznik_detail.html',{'cust':cust,
				'upravit':1, 'popis':'Je nutne vyplnit vsechna pole'})
	
def zamestnanci(request):
	return zamestnanciPage(request,0)

def zamestnanciPage(request,zamestnanci_page):
	zamestnanci_page = int(zamestnanci_page)
	zamestnanci = Zamestnanec.objects.all()
	zamestnanci_list = zamestnanci.order_by('prijmeni')[settings.PAGEITEMS*zamestnanci_page :settings.PAGEITEMS*(zamestnanci_page+1)]
	
	zamestnanci_list_modified = []
	
	for s in zamestnanci_list:
		sm = {'id': s.id, 'prijmeni': s.prijmeni, 'jmeno':s.jmeno,
		       		'mesto': s.mesto, 'ulice':s.ulice,
			       	'psc':s.psc, 'rc':s.rc,
			       	'zisk':	zamestnanecZisk(s.id)}
		zamestnanci_list_modified.append(sm)

	pocet_stran = math.ceil(len(zamestnanci)/settings.PAGEITEMS)

	predchozi = (zamestnanci_page != 0) and (zamestnanci_page - 1)
	nasledujici = (zamestnanci_page < pocet_stran) and (zamestnanci_page + 1)
	
	return	render_to_response('servis/viewZamestnanci.html',{'zamestnanec_list':zamestnanci_list_modified,'zamestnanci_page': zamestnanci_page,'predchozi':predchozi, 'nasledujici':nasledujici})


def detailZamestnance(request, zamestnanec_id):
	z = get_object_or_404(Zamestnanec, id = zamestnanec_id)
	return render_to_response('servis/Zamestnanec_detail.html',{'zamestnanec':z})

def upravitZamestnance(request, zamestnanec_id):
	z = get_object_or_404(Zamestnanec, id = zamestnanec_id)
	return render_to_response('servis/Zamestnanec_detail.html',{'zamestnanec':z, 'upravit':1})
@transaction.autocommit
def upravovaniZamestnance(request, zamestnanec_id):
	try:
        	z = Zamestnanec.objects.get(id=zamestnanec_id)
	except ObjectDoesNotExist:
        	return http.HttpResponseNotFound()

	jmeno = request.POST['jmeno']
	prijmeni = request.POST['prijmeni']
	mesto = request.POST['mesto']
	psc = request.POST['psc']
	ulice = request.POST['ulice']
	rc = request.POST['rc']

	if jmeno and prijmeni and mesto and psc and ulice  and rc:
		z.jmeno =  jmeno
		z.prijmeni = prijmeni
		z.mesto = mesto
		z.psc = psc
		z.ulice = ulice
		z.rc = rc
		z.save()
		return uspech(request,'Data uspesne aktualizovana')
	else:
	 	z = get_object_or_404(Zamestnanec, id = zamestnanec_id)
		return 	render_to_response('servis/Zamestnanec_detail.html',{'zamestnanec':z, 'upravit':1, 'popis':'Je nutne vyplnit vsechna pole'})

def novyZamestnanec(request):
	return render_to_response('servis/novyZamestnanec.html')

@transaction.autocommit
def vytvoreniZamestnance(request):
	jmeno = request.POST['jmeno']
	prijmeni = request.POST['prijmeni']
	mesto = request.POST['mesto']
	psc = request.POST['psc']
	ulice = request.POST['ulice']
	rc = request.POST['rc']
	if jmeno and prijmeni and mesto and psc and ulice  and rc:
		maxId = len(Zamestnanec.objects.all())+1
		z = Zamestnanec(id=maxId, jmeno=jmeno, prijmeni=prijmeni,
				mesto=mesto, psc=psc,
				ulice=ulice,rc=rc)	
		try:
			z.save()
			return uspech(request, 'Uspesne pridani zamestnance')
		except:
			return chyba(request, 'Chyba pri zapisovani zamestnance')
	else:
		return novyZamestnanecZnovu(request,jmeno, prijmeni, mesto, psc, ulice, rc)

def novyZamestnanecZnovu(request, jmeno, prijmeni, mesto, psc, ulice,rc):
	return 	render_to_response('servis/novyZamestnanec.html',{'jmeno':jmeno,
			'prijmeni':prijmeni, 'mesto':mesto, 'psc':psc,
			'ulice':ulice, 'rc':rc, 'popis':'Je nutne vyplnit vsechna potrebna pole'})


def sazebnik(request):
	return sazebnikPage(request,0)
def sazebnikPage(request, sazebnik_page):
	sazebnik_page = int(sazebnik_page)
	sazebnik = Sazebnik.objects.all()
	sazebnik_list =  sazebnik.order_by('nazev_ukonu')[settings.PAGEITEMS*sazebnik_page :settings.PAGEITEMS*(sazebnik_page+1)]
	sazebnik_list_modified = []
	
	for s in sazebnik_list:
		sm = {'id': s.id, 'nazev_ukonu': s.nazev_ukonu, 'popis':
			s.popis, 'cena': s.cena, 'cetnost':
				cetnostUkonu(s.id)}
		sazebnik_list_modified.append(sm)
	
	pocet_stran = math.ceil((len(sazebnik)-1)/settings.PAGEITEMS)

	predchozi = (sazebnik_page != 0) and (sazebnik_page - 1)
	nasledujici = (sazebnik_page < pocet_stran) and (sazebnik_page + 1)
	
	return	render_to_response('servis/viewSazebnik.html',{'sazebnik_list':sazebnik_list_modified,'sazebnik_page':sazebnik_page,'predchozi':predchozi, 'nasledujici':nasledujici})



def novaPolozkaSazebniku(request):
	return render_to_response('servis/novaPolozkaSazebniku.html')
@transaction.autocommit
def vytvoreniPolozkySazebniku(request):
	nazev_ukonu = request.POST['nazev_ukonu']
	popis = request.POST['popis']
	cena = float(request.POST['cena'])
	if nazev_ukonu and popis and cena:
		maxId = len(Sazebnik.objects.all())+1
		z = Sazebnik(id=maxId, nazev_ukonu=nazev_ukonu,
				popis=popis, cena=cena)	
		try:
			z.save()
			return uspech(request, 'Uspesne pridani polozky	sazebniku')
		except:
			return chyba(request, 'Chyba pri zapisovani nove polozky sazebniku')
	else:
		return novyZamestnanecZnovu(request,nazev_ukonu, popis,	cena)
def novyZamestnanecZnovu(request,nazev_ukonu,popis,cena):
	return render_to_response('servis/novaPolozkaSazebniku.html',{'nazev_ukonu':nazev_ukonu,
			'popis':popis, 'cena':cena, 'hlaska':'Je nutne vyplnit vsechna potrebna pole'})



@transaction.autocommit
def upravitPolozkuSazebniku(request, polozka_sazebniku_id):
	try:
        	z = Sazebnik.objects.get(id=polozka_sazebniku_id)
	except ObjectDoesNotExist:
        	return http.HttpResponseNotFound()

	nazev_ukonu = request.POST['nazev_ukonu']
	popis = request.POST['popis']
	cena = float(request.POST['cena'])
	if nazev_ukonu and popis and cena:
		z.nazev_ukonu=nazev_ukonu
		z.popis=popis
		z.cena=cena
		try:
			z.save()
			return HttpResponse("OK")
		except:
			return http.HttpResponseNotFound()
	else:
		return http.HttpResponseNotFound()

def souboryOprav(request):
	return souboryOpravPage(request,0)

def souboryOpravPage(request,souborOprav_page):
	souborOprav_page = int(souborOprav_page)
	souboryOprav = Soubory_oprav.objects.all()
	souboryOprav_list =   souboryOprav.order_by('nazev')[settings.PAGEITEMS*souborOprav_page :settings.PAGEITEMS*(souborOprav_page+1)]
	
	pocet_stran = math.ceil(len(souboryOprav)/settings.PAGEITEMS)

	predchozi = (souborOprav_page != 0) and (souborOprav_page - 1)
	nasledujici = (souborOprav_page < pocet_stran) and (souborOprav_page + 1)
	
	return	render_to_response('servis/viewSouborOprav.html',{'souboryOprav_list':souboryOprav_list,'souborOprav_page':souborOprav_page,'predchozi':predchozi, 'nasledujici':nasledujici})

def souboryOpravVytvorit(request):
	return render_to_response('servis/novySouborOprav.html',{'sazebnik':Sazebnik.objects.all()})

@transaction.commit_on_success
def pridatSouborOprav(request):
	pocetSelectu = int(request.POST['pocetSelectu'])
	nazev = request.POST['nazev']
	maxId = len(Soubory_oprav.objects.all())+1
	z = Soubory_oprav(id=maxId, nazev=nazev)
	try:
		z.save()
	except:
		return chyba(request, 'Chyba pri zapisovani souboru oprav')

	p = 1
	while p <=pocetSelectu :
		
		z.sazebnik.add(Sazebnik.objects.get(id=int(request.POST[str(p)])))
		
		p+=1
	try:
		z.save()
		return uspech(request, 'Uspesne pridani souboru oprav')
	except:
		return chyba(request, 'Chyba pri zapisovani souboru oprav')

def souboryOpravDetail(request, souborOprav_id):
	so = Soubory_oprav.objects.get(id=souborOprav_id)
	return  render_to_response('servis/detailSouboruOprav.html',{'nazev':so, 'sazebnik':so.sazebnik.all()	})

def zakazky(request):
	return zakazkyPage(request, 0)
def zakazkyPage(request, zakazkyPage):
	zakazkyPage = int(zakazkyPage)
	zakazky = Zakazka.objects.all()
	zakazky_list =      zakazky.order_by('-id')[settings.PAGEITEMS*zakazkyPage    :settings.PAGEITEMS*(zakazkyPage+1)]
	
	pocet_stran = math.ceil(len(zakazky)/settings.PAGEITEMS)

	predchozi = (zakazkyPage != 0) and (zakazkyPage - 1)
	nasledujici = (zakazkyPage < pocet_stran) and (zakazkyPage + 1)
	
	return 	render_to_response('servis/viewZakazky.html',{'zakazky_list':zakazky_list,'zakazky_page':zakazkyPage,'predchozi':predchozi, 'nasledujici':nasledujici})

def novaZakazka(request):
	return render_to_response('servis/novaZakazka.html',{'zakaznici':Zakaznik.objects.all(),
			'ukony':Sazebnik.objects.all(),
			'soubory':Soubory_oprav.objects.all()})
@transaction.commit_on_success
def pridaniNoveZakazky(request):
	pocetSelectuUkony = int(request.POST['pocetSelectuUkony'])
	pocetSelectuSoubory= int(request.POST['pocetSelectuSoubory'])
	zakaznik_id = request.POST['zakaznik_id']
	SPZ = request.POST['spz']
	popis = request.POST['popis']
	if popis and SPZ and zakaznik_id and (pocetSelectuSoubory!=-1 or pocetSelectuUkony!=-1)	:
		if pocetSelectuUkony!=-1:
			maxID = len(Zakazka.objects.all())+1
			z = Zakazka(id=maxID,
					zakaznik=Zakaznik.objects.get(id=zakaznik_id),
					spz = SPZ,
				       	popis =popis)

			try:
				z.save()
			except:
				return chyba(request, 'Chyba pri zapisovani souboru oprav')
		
			p = 1
			while p <=pocetSelectuUkony :
				us_maxID = len(Ukon_sazebnik.objects.all())+1
				us = Ukon_sazebnik(id=us_maxID, 
						sazebnik = Sazebnik.objects.get(id=int(request.POST[str(p)])), 
						stav =	Stav_ukonu.objects.get(id=1),
						poznamka = 'neni',						
						zakazka = z)
				p+=1
				
				try:
					us.save()
				except:
					return chyba(request,'Chyba pri	zapisovani ukonu')
			return uspech(request, 'Zakazka pridana')

		else:
			maxID = len(Zakazka.objects.all())+1
			z = Zakazka(id=maxID,
					zakaznik=Zakaznik.objects.get(id=zakaznik_id),
					spz = SPZ,
				       	popis =popis)
			try:
				z.save()
			except:
				return chyba(request, 'Chyba pri zapisovani souboru oprav')
		
			p = 1
			while p <= pocetSelectuSoubory :
				soubor = Soubory_oprav.objects.get(id =	int(request.POST[str(p)]))
				polozky_sazebniku = soubor.sazebnik.all()
				for s in polozky_sazebniku :
					us_maxID=len(Ukon_sazebnik.objects.all())+1
					us = Ukon_sazebnik(id=us_maxID,
							sazebnik = s,
							stav =	Stav_ukonu.objects.get(id=1),
							poznamka='neni',
							zakazka=z)
					try:
						us.save()
					except:
						return chyba(request,	'chyba pri zapisovani souboru oprav')	
				p+=1
				
			return uspech(request, 'Zakazka pridana')
	
def detailZakazky(request, zakazka_id):
	z = get_object_or_404(Zakazka, id = zakazka_id)
	return     render_to_response('servis/Zakazka_detail.html',{'seznamZamestnancu':Zamestnanec.objects.all(),'vsechnyStavy':Stav_ukonu.objects.all(),'zakazka':z,   'ukolyVZakazce':Ukon_sazebnik.objects.filter(zakazka=z)})

@transaction.autocommit
def ukonSazebnikUpravitPoznamku(request, ukon_sazebnik_id):
	poznamka = request.POST['poznamka']
	z = get_object_or_404(Ukon_sazebnik, id = ukon_sazebnik_id)
	z.poznamka = poznamka
	try:
		z.save()
		return HttpResponse("OK")
	except:
		return http.HttpResponseNotFound()
def zjistitIdStavu(request):
	stav = request.POST['stav']
	z.get_object_or_404(Stav_ukonu, nazev=stav)
	return HttpResponse(z.id)
@transaction.autocommit
def ukonSazebnikUpravitStav(request, ukon_sazebnik_id):
	stav_id = request.POST['stav_id']
	z = get_object_or_404(Ukon_sazebnik, id=ukon_sazebnik_id)
	s =  get_object_or_404(Stav_ukonu, id=stav_id)
	z.stav =s
	try:
		z.save()
		return HttpResponse(s.nazev)
	except:
		return HttpResponseNotFound()
@transaction.autocommit
def novaPraceNaUkonu(request):
	ukon_id = request.POST['ukon_id']
	DD = request.POST['DD']
	MM = request.POST['MM']
	YY = request.POST['YY']
	zacatek_m = request.POST['zacatek_m']
	zacatek_h = request.POST['zacatek_h']
	konec_m = request.POST['konec_m']
	konec_h = request.POST['konec_h']
	zamestnanec_id = request.POST['zamestnanec_id']
	maxID= len(Prace_na_ukonu.objects.all())+1
	zacatek = datetime.datetime(int(YY), int(MM), int(DD), int (zacatek_h), int(zacatek_m))
	konec = datetime.datetime(int(YY), int(MM), int(DD), int(konec_h), int(konec_m))

	p = Prace_na_ukonu(id=maxID,zacatek= zacatek, konec = konec , ukon = Ukon_sazebnik.objects.get(id=ukon_id), zamestnanec = Zamestnanec.objects.get(id=zamestnanec_id))
	try:
		p.save()
		return HttpResponse(ukon_id)
	except:
		return HttpResponseNotFound()
	    		  
def ziskNaZakaznika(request, zakaznik_id):
	z = Zakaznik.objects.get(id=zakaznik_id)
	#listUkonu = Ukon_sazebnik.objects.filter(zakazka.zakaznik=z)	
	cena =0
	for ukon in listUkonu:
		cena += ukon.sazebnik.cena
	return HttpResponse(cena)
			
def cetnostUkonu( sazebnik_id):
	pocet = len(Ukon_sazebnik.objects.filter(sazebnik=sazebnik_id))
	celkovyPocet = len(Ukon_sazebnik.objects.all())
	return (100*pocet/celkovyPocet)

def zakaznikZisk(zakaznik_id):
	z = get_object_or_404(Zakaznik, id=zakaznik_id)
	zakazky = Zakazka.objects.filter(zakaznik = z)
	soucet = 0
	for x in zakazky:
		us = Ukon_sazebnik.objects.filter( zakazka=x,stav=get_object_or_404(Stav_ukonu,id=4))
		for y in us:
			pu = Prace_na_ukonu.objects.filter(ukon=y)
			for u in pu:
				rozdil = u.konec- u.zacatek
				soucet-= rozdil.seconds*settings.HODINOVA_MZDA/3600
			soucet+=y.sazebnik.cena
	return soucet

def zamestnanecZisk(zamestnanec_id):
	z = get_object_or_404(Zamestnanec , id = zamestnanec_id)
	prace = Prace_na_ukonu.objects.filter(zamestnanec=z)
	soucet = 0
	for pr in prace:
		soucet -= ( pr.konec -pr.zacatek ).seconds*settings.HODINOVA_MZDA/3600
		soucet += pr.ukon.sazebnik.cena
	return soucet
